/**
 * Created by meiguizhinian on 2018/6/26
 * Copyright © 2018 lixiaolong. All rights reserved.
 */

//TODO：等待完成
//单例/全静态
ivy.Tools = {
	pushFunctionToCocosThread : function(call) {
		let sch = cc.director.getScheduler();
		sch.performFunctionInCocosThread(call);
	},
	//
	// template<typename T>
	// static int32_t Sgn(T t)
	// {
	// 	if (t > 0)
	// 		return 1;
	// 	else if (t < 0)
	// 		return -1;
	// 	else
	// 		return 0;
	// }
	// static int32_t Random(int32_t lower, int32_t upper)
	// {
	// 	return cocos2d::RandomHelper::random_int(lower, upper);
	// }
	//
	// static float Random(float lower, float upper)
	// {
	// 	return cocos2d::RandomHelper::random_real(lower, upper);
	// }
	//
	// static double Random(double lower, double upper)
	// {
	// 	return cocos2d::RandomHelper::random_real(lower, upper);
	// }
	//
	getAlphaFromInt32 : function(color) {
		return (color >> 24 ) & 0xff;
	},

	getColor3BFromInt32 : function(color) {
		let r = (color >> 16) & 0xff;
		let g = (color >> 8) & 0xff;
		let b = color & 0xff;
		return cc.color(r,g,b);
	},

	getColor4BFromInt32: function (color) {
		let a = (color >> 24) & 0xff;
		let r = (color >> 16) & 0xff;
		let g = (color >> 8) & 0xff;
		let b = color & 0xff;
		return cc.color(r, g, b, a);
	},

	// static cocos2d::Color4F getColor4FFromInt32(int32_t color)
	// {
	// 	float a = (color >> 24) & 0xff;
	// 	float r = (color >> 16) & 0xff;
	// 	float g = (color >> 8) & 0xff;
	// 	float b = color & 0xff;
	// 	return cocos2d::Color4F(r/255.f, g/255.0f, b/255.0f, a/255.0f);
	// }
	//
	getPointsDegree : function(p1, p2) {
		let degree = Math.atan2(p1.x - p2.x, p1.y - p2.y) * 180 / 3.14;
		if (degree < 0)
			degree = 360 + degree;
		return degree;
	},
	//
	// //判断Rect是否相交
	// static bool isIntersectsRect(const cocos2d::Rect& atkBox, const cocos2d::Rect& colBox)
	// {
	// 	if (atkBox.size.width == 0 ||
	// 		atkBox.size.height == 0 ||
	// 		colBox.size.width == 0 ||
	// 		colBox.size.height == 0)
	// 		return false;
	// 	else
	// 		return atkBox.intersectsRect(colBox);
	// }
	//
	// //转换成字符串
	// template<typename Val>
	// static std::string toString(Val val)
	// {
	// 	std::stringstream stm;
	// 	stm << val;
	// 	return stm.str();
	// }
	//
	// enum class TimeShowType
	// {
	// 	eS,
	// 	eMS,
	// 	eHMS,
	// 	eAuto,
	// };
	// //转换成时间字符串 返回值形如(1:10:59)
	// static std::string toTime(int32_t t, TimeShowType tst= TimeShowType::eHMS)
	// {
	// 	auto& gc = cc::GlobleConfig::getInstance();
	// 	auto second = t / static_cast<int32_t>(gc.getFPS());
	// 	auto h = second / (60* 60);
	// 	auto m = second % (60 * 60) / 60;
	// 	auto s = second % (60);
	//
	// 	std::stringstream stm;
	// 	auto typeV = static_cast<int32_t>(tst);
	// 	if (typeV >= (int32_t)TimeShowType::eHMS || (tst == TimeShowType::eAuto&&h > 0))
	// 	{
	// 		if (h < 10)
	// 			stm << "0";
	// 		stm << h << ":";
	// 	}
	// 	if (typeV >= (int32_t)TimeShowType::eMS || (tst == TimeShowType::eAuto&&m > 0))
	// 	{
	// 		if (m < 10)
	// 			stm << "0";
	// 		stm << m << ":";
	// 	}
	// 	if (s < 10)
	// 		stm << "0";
	// 	stm << s;
	// 	return stm.str();
	// }
	//
	// template<typename T = uint32_t>
	// 	static T hexStrToNumber(const std::string& hexStr)
	// {
	// 	T value;
	// 	sscanf(hexStr.c_str(), "%x", &value);
	// 	return value;
	// }
	//
	// //转换成int
	// static int32_t toInt(const std::string& str)
	// {
	// 	std::stringstream stm(str);
	// 	int n = 0;
	// 	stm >> n;
	// 	return n;
	// }
	//
	// static int16_t toInt16(const std::string& str)
	// {
	// 	std::stringstream stm(str);
	// 	int16_t n = 0;
	// 	stm >> n;
	// 	return n;
	// }
	//
	// static uint16_t toUInt16(const std::string& str)
	// {
	// 	std::stringstream stm(str);
	// 	uint16_t n = 0;
	// 	stm >> n;
	// 	return n;
	// }
	//
	// static float toFloat(const std::string& str)
	// {
	// 	std::stringstream stm(str);
	// 	float n = 0;
	// 	stm >> n;
	// 	return n;
	// }
	//
	// static uint32_t toUInt(const std::string& str)
	// {
	// 	std::stringstream stm(str);
	// 	uint32_t n = 0;
	// 	stm >> n;
	// 	return n;
	// }
	//
	// template<typename T>
	// static T convertFormString(const std::string& str)
	// {
	// 	std::stringstream stm(str);
	// 	T n;
	// 	stm >> n;
	// 	return n;
	// }
	//
	// //转换成浮点数
	// template<typename Val>
	// static float toFloat(Val val)
	// {
	// 	std::stringstream stm;
	// 	float n = 0;
	// 	stm << val;
	// 	stm >> n;
	// 	return n;
	// }
	//插值函数
	lerp : function(min, max, curV, maxV) {
		return curV*(max - min) / maxV + min;
	},
	//GL坐标转换为编辑器坐标
	ConvertPointFromGL : function(p) {
		return cc.p(p.x, ivy.GlobleConfig.getInstance().getScreenHeight() - p.y);
	},
	//编辑器坐标转换为GL坐标
	ConvertPointToGL : function(p) {
		return this.ConvertPointFromGL(p);
	},
	//////////////////////////////////////////////////////////////////////////
	// //通过字符分割字符串
	// static void split(std::string& s, std::string delim, std::vector< std::string >* ret)
	// {
	// 	size_t last = 0;
	// 	size_t index = s.find_first_of(delim, last);
	// 	while (index != std::string::npos)
	// 	{
	// 		ret->push_back(s.substr(last, index - last));
	// 		last = index + 1;
	// 		index = s.find_first_of(delim, last);
	// 	}
	// 	if (index - last > 0)
	// 	{
	// 		ret->push_back(s.substr(last, index - last));
	// 	}
	// }
	//
	// static void split(const std::string& s, std::string delim, std::vector< std::string >* ret)
	// {
	// 	size_t last = 0;
	// 	size_t index = s.find_first_of(delim, last);
	// 	while (index != std::string::npos)
	// 	{
	// 		ret->push_back(s.substr(last, index - last));
	// 		last = index + 1;
	// 		index = s.find_first_of(delim, last);
	// 	}
	// 	if (index - last > 0)
	// 	{
	// 		ret->push_back(s.substr(last, index - last));
	// 	}
	// }
	//
	// static std::vector<std::string> split(const std::string& s,const std::string& delim)
	// {
	// 	std::vector<std::string> vec;
	// 	split(s,delim,&vec);
	// 	return vec;
	// }
	// //////////////////////////////////////////////////////////////////////////
	// class IntCode
	// {
	// 	public:
	// 		template<typename... Args>
	// 	static std::string& encode(std::string& dest, Args... args)
	// {
	// 	return encodeImpl(dest, std::forward<Args>(args)...);
	// }
	//
	// template<typename... Args>
	// static char* encode(char* dest, Args... args)
	// {
	// 	return encodeImpl(dest, std::forward<Args>(args)...);
	// }
	//
	// template<typename... Args>
	// static size_t decode(const std::string& dest, Args&... args)
	// {
	// 	return decodeImpl(static_cast<size_t>(0), dest, std::forward<Args&>(args)...);
	// }
	//
	// template<typename... Args>
	// static size_t decode(size_t start, const std::string& dest, Args&... args)
	// {
	// 	return decodeImpl(start, dest, std::forward<Args&>(args)...);
	// }
	//
	// template<typename Return>
	// static Return decode(const std::string& dest)
	// {
	// 	Return ret = 0;
	// 	decode(dest, ret);
	// 	return ret;
	// }
	//
	// template<typename Return>
	// static Return decode(size_t start, const std::string& dest)
	// {
	// 	Return ret = 0;
	// 	decode(start, dest, ret);
	// 	return ret;
	// }
	//
	// template<typename... Args>
	// static const char* decode(const char* dest, Args&... args)
	// {
	// 	return decodeImpl(dest, std::forward<Args&>(args)...);
	// }
	//
	// template<typename Return>
	// static Return decode(const char* dest)
	// {
	// 	Return ret = 0;
	// 	decode(dest, ret);
	// 	return ret;
	// }
	//
	// private:
	// 	template<typename Int, typename... Args>
	// static std::string& encodeImpl(std::string& dest, Int val, Args... args)
	// {
	// 	encodeImpl(dest, val);
	// 	encodeImpl(dest, std::forward<Args>(args)...);
	// 	return dest;
	// }
	//
	// template<typename Int>
	// static std::string& encodeImpl(std::string& dest, Int val)
	// {
	// 	auto const sz = dest.size();
	// 	dest.resize(sz + sizeof(val));
	// 	encodeImpl(&dest[sz], val);
	// 	return dest;
	// }
	//
	// template<typename Int, typename... Args>
	// static char* encodeImpl(char* dest, Int val, Args... args)
	// {
	// 	encodeImpl(dest, val);
	// 	return encodeImpl(dest + sizeof(val), std::forward<Args>(args)...);
	// }
	//
	// template<typename Int>
	// static char* encodeImpl(char* dest, Int val)
	// {
	// 	typedef typename std::make_unsigned<Int>::type Rlt;
	// 	for (size_t i = 0; i < sizeof(Int); ++i)
	// 	dest[i] = static_cast<char>(static_cast<Rlt>(val) >> ((sizeof(Int) - i - 1) * 8));
	// 	return dest + sizeof(val);
	// }
	//
	// template<typename Int, typename... Args>
	// static size_t decodeImpl(size_t start, const std::string& dest, Int& val, Args&... args)
	// {
	// 	decodeImpl(start, dest, val);
	// 	return sizeof(Int) + decodeImpl(start + sizeof(Int), dest, std::forward<Args&>(args)...);
	// }
	//
	// template<typename Int>
	// static size_t decodeImpl(size_t start, const std::string& dest, Int& val)
	// {
	// 	assert(dest.size() - start >= sizeof(val));
	// 	decodeImpl(&dest[0] + start, val);
	// 	return sizeof(val);
	// }
	//
	// template<typename Int, typename... Args>
	// static const char* decodeImpl(const char* dest, Int& val, Args&... args)
	// {
	// 	decodeImpl(dest, val);
	// 	return decodeImpl(dest + sizeof(val), std::forward<Args&>(args)...);
	// }
	//
	// template<typename Int>
	// static const char* decodeImpl(const char* dest, Int& val)
	// {
	// 	typedef typename std::make_unsigned<Int>::type Rlt;
	//
	// 	Rlt rlt = 0;
	// 	for (size_t i = 0; i < sizeof(Int); ++i)
	// 	rlt |= static_cast<Rlt>(static_cast<uint8_t>(dest[i])) << ((sizeof(Int) - i - 1) * 8);
	// 	val = static_cast<Int>(rlt);
	// 	return dest + sizeof(Int);
	// }
	//
	// };
	//
	// struct CodecImpl
	// {
	// 	template<typename Int>
	// static void encode(std::string& dest, Int val,
	// 	typename std::enable_if<std::is_integral<Int>::value>::type* = nullptr)
	// 	{
	// 		IntCode::encode(dest, val);
	// 	}
	//
	// 	static void encode(std::string& dest, const std::string& src)
	// 	{
	// 		IntCode::encode(dest, static_cast<uint32_t>(src.size()));
	// 		dest += src;
	// 	}
	//
	// 	template<typename Value>
	// static void encode(std::string& dest, const Value& val,
	// 	typename std::enable_if<!std::is_integral<Value>::value>::type* = nullptr)
	// 	{
	// 		val.encode(dest);
	// 	}
	//
	// 	template<typename Int>
	// static void decode(uint32_t& start, const std::string& src, Int& val,
	// 	typename std::enable_if<std::is_integral<Int>::value>::type* = nullptr)
	// 	{
	// 		IntCode::decode(start, src, val);
	// 		start += sizeof(val);
	// 	}
	//
	// 	static void decode(uint32_t& start, const std::string& src, std::string& dest)
	// 	{
	// 		uint32_t len = 0;
	// 		IntCode::decode(start, src, len);
	// 		start += sizeof(len);
	//
	// 		dest.assign(src.substr(start, len));
	// 		start += len;
	// 	}
	//
	// 	template<typename Value>
	// static void decode(uint32_t& start, const std::string& src, Value& val,
	// 	typename std::enable_if<!std::is_integral<Value>::value>::type* = nullptr)
	// 	{
	// 		val.decode(start, src);
	// 	}
	//
	// };
	//
	// static inline void encode(std::string&)
	// {}
	//
	// template<typename First, typename... Args>
	// static inline void encode(std::string& dest, First&& first, Args&&... args)
	// {
	// 	CodecImpl::encode(dest, std::forward<First&&>(first));
	// 	encode(dest, std::forward<Args&&>(args)...);
	// }
	//
	// template<typename First, typename... Args>
	// static inline std::string encode(First&& first, Args&&... args)
	// {
	// 	std::string ret;
	// 	encode(ret, std::forward<First&&>(first), std::forward<Args&&>(args)...);
	// 	return ret;
	// }
	//
	//
	// static inline void decode(uint32_t&, const std::string&)
	// {}
	//
	// template<typename First, typename... Args>
	// static inline void decode(uint32_t& start, const std::string& src, First&& first, Args&&... args)
	// {
	// 	CodecImpl::decode(start, src, std::forward<First&&>(first));
	// 	decode(start, src, std::forward<Args&&>(args)...);
	// }
	//
	// template<typename... Args>
	// static inline void decode(const std::string& src, Args&&... args)
	// {
	// 	uint32_t start = 0;
	// 	decode(start, src, std::forward<Args&&>(args)...);
	// }
	//
	// template<typename Value>
	// static inline Value decode(uint32_t& start, const std::string& src)
	// {
	// 	Value ret;
	// 	decode(start, src, ret);
	// 	return std::move(ret);
	// }
	//
	// template<typename Value>
	// static inline Value decode(const std::string& src)
	// {
	// 	Value ret;
	// 	uint32_t start = 0;
	// 	decode(start, src, ret);
	// 	return std::move(ret);
	// }
	// enum FormatSize
	// {
	// 	eShort=256,
	// 		eNormal=512,
	// 		eLong=1024,
	// };
	// template<typename ... Args>
	// static std::string format(const std::string& formatStr, FormatSize length,Args&&... args)
	// {
	// 	switch (length)
	// 	{
	// 		case cc::Tools::eShort:
	// 		{
	// 			char s[256];
	// 			sprintf(s, formatStr.c_str(), std::forward<Args&&>(args)...);
	// 			std::string ss(s);
	// 			return ss;
	// 		}
	// 		case cc::Tools::eLong:
	// 		{
	// 			char s[1024];
	// 			sprintf(s, formatStr.c_str(), std::forward<Args&&>(args)...);
	// 			std::string ss(s);
	// 			return ss;
	// 		}
	// 		case cc::Tools::eNormal:
	// 		default:
	// 		{
	// 			char s[512];
	// 			sprintf(s, formatStr.c_str(), std::forward<Args&&>(args)...);
	// 			std::string ss(s);
	// 			return ss;
	// 		}
	// 	}
	// }
	//
	// static cocos2d::RenderTexture* screenShot(const bool bIsSave, std::function<void(cocos2d::RenderTexture*, const std::string&)> pFuncCallback,cocos2d::Node* shotNode=nullptr,cocos2d::Texture2D::PixelFormat pFormat=cocos2d::Texture2D::PixelFormat::RGBA8888)
	// {
	// 	//使用屏幕尺寸初始化一个空的渲染纹理对象
	// 	cocos2d::Size sizeWin = cocos2d::Director::getInstance()->getWinSize();
	// 	cocos2d::RenderTexture* textureScreen =
	// 		cocos2d::RenderTexture::create(sizeWin.width, sizeWin.height, pFormat);
	// 	//清除数据并开始获取
	// 	textureScreen->beginWithClear(0.0f, 0.0f, 0.0f, 0.0f);
	// 	if (!shotNode)
	// 	//遍历场景节点对象，填充纹理到texure中
	// 		cocos2d::Director::getInstance()->getRunningScene()->visit();
	// else
	// 	shotNode->visit();
	// 	//结束获取
	// 	textureScreen->end();
	// 	//保存为PNG图
	// 	if (bIsSave)
	// 	{
	// 		static int s_iSerialNumber = 0;
	// 		textureScreen->saveToFile(
	// 			cocos2d::CCString::createWithFormat("ScreenShot_%04d.png", ++s_iSerialNumber)->getCString(),
	// 		cocos2d::Image::Format::PNG,
	// 		true,
	// 		pFuncCallback);
	// 	}
	// 	else
	// 	{
	// 		if (nullptr != pFuncCallback)
	// 		{
	// 			pFuncCallback(textureScreen, "");
	// 		}
	// 	}
	// 	return textureScreen;
	// }
	//
	// static void screenShot(cocos2d::RenderTexture* textureScreen, const bool bIsSave, std::function<void(cocos2d::RenderTexture*, const std::string&)> pFuncCallback, cocos2d::Node* shotNode = nullptr)
	// {
	// 	//使用屏幕尺寸初始化一个空的渲染纹理对象
	// 	cocos2d::Size sizeWin = cocos2d::Director::getInstance()->getWinSize();
	// 	//清除数据并开始获取
	// 	textureScreen->beginWithClear(0.0f, 0.0f, 0.0f, 0.0f);
	// 	if (!shotNode)
	// 	//遍历场景节点对象，填充纹理到texure中
	// 		cocos2d::Director::getInstance()->getRunningScene()->visit();
	// else
	// 	shotNode->visit();
	// 	//结束获取
	// 	textureScreen->end();
	// 	//保存为PNG图
	// 	if (bIsSave)
	// 	{
	// 		static int s_iSerialNumber = 0;
	// 		textureScreen->saveToFile(
	// 			cocos2d::CCString::createWithFormat("ScreenShot_%04d.png", ++s_iSerialNumber)->getCString(),
	// 		cocos2d::Image::Format::PNG,
	// 		true,
	// 		pFuncCallback);
	// 	}
	// 	else
	// 	{
	// 		if (nullptr != pFuncCallback)
	// 		{
	// 			pFuncCallback(textureScreen, "");
	// 		}
	// 	}
	// }
	//
	//
	// static std::string& replace_all(std::string& str, const std::string& old_value, const std::string&  new_value)
	// {
	// 	while (true)
	// 	{
	// 		std::string::size_type   pos(0);
	// 		if ((pos = str.find(old_value)) != std::string::npos)
	// 		{
	// 			str.replace(pos, old_value.length(), new_value);
	// 		}
	// 		else { break; }
	// 	}
	// 	return   str;
	// }
	//
	// static std::string& replace_all_distinct(std::string& str, const std::string& old_value, const std::string& new_value)
	// {
	// 	for (std::string::size_type pos(0); pos != std::string::npos; pos += new_value.length())
	// 	{
	// 		if ((pos = str.find(old_value, pos)) != std::string::npos)
	// 		{
	// 			str.replace(pos, old_value.length(), new_value);
	// 		}
	// 		else { break; }
	// 	}
	// 	return   str;
	// }
};